//
// DO NOT MODIFY THIS FILE - it is generated using optionpg on lpg.OptionEnum
//
package lpg;

class OptionParser
{
    OptionParser(Option option, char[] param, int end)
    {
        this.option = option;
        this.param = param;
        this.end = end;
    }

    int classifyOption(int start, boolean flag)
    {
        int p = start;
        char c = param[start];
        switch (c)
        {
            case 'A': case 'a':
                return classifyA(start, ++p, flag);
            case 'B': case 'b':
                return classifyB(start, ++p, flag);
            case 'C': case 'c':
                return classifyC(start, Util.prefixMatch(param, ++p, end, "ONFLICTS", "onflicts") + p, flag);
            case 'D': case 'd':
                return classifyD(start, ++p, flag);
            case 'E': case 'e':
                return classifyE(start, ++p, flag);
            case 'F': case 'f':
                return classifyF(start, ++p, flag);
            case 'G': case 'g':
                return classifyG(start, ++p, flag);
            case 'H': case 'h':
                return classifyH(start, Util.prefixMatch(param, ++p, end, "EADERS", "eaders") + p, flag);
            case 'I': case 'i':
                return classifyI(start, ++p, flag);
            case 'L': case 'l':
                return classifyL(start, ++p, flag);
            case 'M': case 'm':
                return classifyM(start, ++p, flag);
            case 'N': case 'n':
                return classifyN(start, ++p, flag);
            case 'O': case 'o':
                return classifyO(start, ++p, flag);
            case 'P': case 'p':
                return classifyP(start, ++p, flag);
            case 'Q': case 'q':
                return classifyQ(start, Util.prefixMatch(param, ++p, end, "UIET", "uiet") + p, flag);
            case 'R': case 'r':
                return classifyR(start, ++p, flag);
            case 'S': case 's':
                return classifyS(start, ++p, flag);
            case 'T': case 't':
                return classifyT(start, ++p, flag);
            case 'V': case 'v':
                return classifyV(start, ++p, flag);
            case 'W': case 'w':
                return classifyW(start, Util.prefixMatch(param, ++p, end, "ARNINGS", "arnings") + p, flag);
            case 'X': case 'x':
                return classifyX(start, Util.prefixMatch(param, ++p, end, "REFERENCE", "reference") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyA(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "ACTION_BLOCK, AST_DIRECTORY, AST_TYPE, ATTRIBUTES, AUTOMATIC_AST")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                return classifyAAs(start, ++p, flag);
            case 'U': case 'u':
                int iAU = Util.prefixMatch(param, ++p, end, "TOMATICAST", "tomaticast");
                return classifyAAs(start, (iAU == 7 ? Util.prefixMatch(param, p + iAU, end, "_AST", "-ast") : 0) + p + iAU, flag);
            case 'B': case 'b':
                return classifyABs(start, ++p, flag);
            case 'C': case 'c':
                int iAC = Util.prefixMatch(param, ++p, end, "TIONBLOCK", "tionblock");
                return classifyABs(start, (iAC == 4 ? Util.prefixMatch(param, p + iAC, end, "_BLOCK", "-block") : 0) + p + iAC, flag);
            case 'D': case 'd':
                return classifyAD(start, ++p, flag);
            case 'S': case 's':
                int iAS = Util.prefixMatch(param, ++p, end, "T", "t");
                return classifyAS(start, p + iAS, flag, iAS == 1);
            case 'T': case 't':
                return classifyAT(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyAAs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.AUTOMATIC_AST.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.AUTOMATIC_AST.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyABs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.ACTION_BLOCK.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyAD(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.AST_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyAS(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "AST_DIRECTORY, AST_TYPE")
                        : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'D': case 'd':
                return classifyASTD(start, Util.prefixMatch(param, ++p, end, "IRECTORY", "irectory") + p, flag);
            case 'T': case 't':
                return classifyASTT(start, Util.prefixMatch(param, ++p, end, "YPE", "ype") + p, flag);
            case '_': case '-':
                return classifyAST_(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyASTD(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.AST_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyASTT(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.AST_TYPE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyAST_(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "AST_DIRECTORY, AST_TYPE")
                        : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'D': case 'd':
                return classifyAST_D(start, Util.prefixMatch(param, ++p, end, "IRECTORY", "irectory") + p, flag);
            case 'T': case 't':
                return classifyAST_T(start, Util.prefixMatch(param, ++p, end, "YPE", "ype") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyAST_D(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.AST_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyAST_T(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.AST_TYPE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyAT(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.ATTRIBUTES.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.AST_TYPE.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'T': case 't':
                return classifyATT(start, Util.prefixMatch(param, ++p, end, "RIBUTES", "ributes") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyATT(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.ATTRIBUTES.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyB(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "BACKTRACK, BYTE")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                return classifyBA(start, Util.prefixMatch(param, ++p, end, "CKTRACK", "cktrack") + p, flag);
            case 'Y': case 'y':
                return classifyBY(start, Util.prefixMatch(param, ++p, end, "TE", "te") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyBA(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.BACKTRACK.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyBY(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.BYTE.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyC(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.CONFLICTS.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyD(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "DAT_DIRECTORY, DAT_FILE, DCL_FILE, DEBUG, DEF_FILE, DIRECTORY_PREFIX")
                        : q < 0 ? OptionEnum.DEBUG.setBooleanValue(false, p, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                int iDA = Util.prefixMatch(param, ++p, end, "T", "t");
                return classifyDA(start, p + iDA, flag, iDA == 1);
            case 'C': case 'c':
                int iDC = Util.prefixMatch(param, ++p, end, "LFILE", "lfile");
                return classifyDCs(start, (iDC == 1 ? Util.prefixMatch(param, p + iDC, end, "_FILE", "-file") : 0) + p + iDC, flag);
            case 'D': case 'd':
                return classifyDD(start, ++p, flag);
            case 'E': case 'e':
                return classifyDE(start, ++p, flag);
            case 'F': case 'f':
                return classifyDF(start, ++p, flag);
            case 'I': case 'i':
                int iDI = Util.prefixMatch(param, ++p, end, "RECTORYPREFIX", "rectoryprefix");
                return classifyDIs(start, (iDI == 7 ? Util.prefixMatch(param, p + iDI, end, "_PREFIX", "-prefix") : 0) + p + iDI, flag);
            case 'P': case 'p':
                return classifyDIs(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyDA(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "DAT_DIRECTORY, DAT_FILE")
                        : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'D': case 'd':
                return classifyDATD(start, Util.prefixMatch(param, ++p, end, "IRECTORY", "irectory") + p, flag);
            case 'F': case 'f':
                return classifyDATF(start, Util.prefixMatch(param, ++p, end, "ILE", "ile") + p, flag);
            case '_': case '-':
                return classifyDAT_(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyDATD(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.DAT_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyDATF(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.DAT_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyDAT_(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "DAT_DIRECTORY, DAT_FILE")
                        : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'D': case 'd':
                return classifyDAT_D(start, Util.prefixMatch(param, ++p, end, "IRECTORY", "irectory") + p, flag);
            case 'F': case 'f':
                return classifyDAT_F(start, Util.prefixMatch(param, ++p, end, "ILE", "ile") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyDAT_D(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.DAT_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyDAT_F(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.DAT_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyDCs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.DCL_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyDD(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.DAT_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyDE(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.DEBUG.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.DEF_FILE.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'B': case 'b':
                return classifyDEB(start, Util.prefixMatch(param, ++p, end, "UG", "ug") + p, flag);
            case 'F': case 'f':
                int iDEF = Util.prefixMatch(param, ++p, end, "FILE", "file");
                return classifyDEFs(start, (iDEF == 0 ? Util.prefixMatch(param, p + iDEF, end, "_FILE", "-file") : 0) + p + iDEF, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyDEB(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.DEBUG.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyDEFs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.DEF_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyDF(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "DAT_FILE, DCL_FILE, DEF_FILE")
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyDIs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.DIRECTORY_PREFIX.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyE(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "EDIT, ERROR_MAPS, ESCAPE, EXPORT_TERMINALS, EXTENDS_PARSETABLE")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'D': case 'd':
                return classifyED(start, Util.prefixMatch(param, ++p, end, "IT", "it") + p, flag);
            case 'M': case 'm':
                return classifyEMs(start, ++p, flag);
            case 'R': case 'r':
                int iER = Util.prefixMatch(param, ++p, end, "RORMAPS", "rormaps");
                return classifyEMs(start, (iER == 3 ? Util.prefixMatch(param, p + iER, end, "_MAPS", "-maps") : 0) + p + iER, flag);
            case 'P': case 'p':
                return classifyEP(start, ++p, flag);
            case 'S': case 's':
                return classifyES(start, Util.prefixMatch(param, ++p, end, "CAPE", "cape") + p, flag);
            case 'T': case 't':
                return classifyET(start, ++p, flag);
            case 'X': case 'x':
                return classifyEX(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyED(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.EDIT.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyEMs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.ERROR_MAPS.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyEP(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.EXTENDS_PARSETABLE.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.EXTENDS_PARSETABLE.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyES(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.ESCAPE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyET(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.EXPORT_TERMINALS.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyEX(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "EXPORT_TERMINALS, EXTENDS_PARSETABLE")
                        : q < 0 ? OptionEnum.EXTENDS_PARSETABLE.setBooleanValue(false, p, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'P': case 'p':
                int iEXP = Util.prefixMatch(param, ++p, end, "ORTTERMINALS", "ortterminals");
                return classifyEXPs(start, (iEXP == 3 ? Util.prefixMatch(param, p + iEXP, end, "_TERMINALS", "-terminals") : 0) + p + iEXP, flag);
            case 'T': case 't':
                int iEXT = Util.prefixMatch(param, ++p, end, "ENDSPARSETABLE", "endsparsetable");
                return classifyEXTs(start, (iEXT == 4 ? Util.prefixMatch(param, p + iEXT, end, "_PARSETABLE", "-parsetable") : 0) + p + iEXT, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyEXPs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.EXPORT_TERMINALS.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyEXTs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.EXTENDS_PARSETABLE.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.EXTENDS_PARSETABLE.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyF(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "FACTORY, FILE_PREFIX, FILTER, FIRST, FOLLOW")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                return classifyFA(start, Util.prefixMatch(param, ++p, end, "CTORY", "ctory") + p, flag);
            case 'I': case 'i':
                return classifyFI(start, ++p, flag);
            case 'O': case 'o':
                return classifyFO(start, Util.prefixMatch(param, ++p, end, "LLOW", "llow") + p, flag);
            case 'P': case 'p':
                return classifyFP(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyFA(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.FACTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyFI(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "FILE_PREFIX, FILTER, FIRST")
                        : q < 0 ? OptionEnum.FIRST.setBooleanValue(false, p, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'L': case 'l':
                return classifyFIL(start, ++p, flag);
            case 'R': case 'r':
                return classifyFIR(start, Util.prefixMatch(param, ++p, end, "ST", "st") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyFIL(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "FILE_PREFIX, FILTER")
                        : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'E': case 'e':
                int iFILE = Util.prefixMatch(param, ++p, end, "PREFIX", "prefix");
                return classifyFILEs(start, (iFILE == 0 ? Util.prefixMatch(param, p + iFILE, end, "_PREFIX", "-prefix") : 0) + p + iFILE, flag);
            case 'T': case 't':
                return classifyFILT(start, Util.prefixMatch(param, ++p, end, "ER", "er") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyFILEs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.FILE_PREFIX.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyFILT(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.FILTER.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyFIR(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.FIRST.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyFO(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.FOLLOW.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyFP(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.FILE_PREFIX.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyG(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "GLR, GOTO_DEFAULT")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'D': case 'd':
                return classifyGDs(start, ++p, flag);
            case 'O': case 'o':
                int iGO = Util.prefixMatch(param, ++p, end, "TODEFAULT", "todefault");
                return classifyGDs(start, (iGO == 2 ? Util.prefixMatch(param, p + iGO, end, "_DEFAULT", "-default") : 0) + p + iGO, flag);
            case 'L': case 'l':
                return classifyGL(start, Util.prefixMatch(param, ++p, end, "R", "r") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyGDs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.GOTO_DEFAULT.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyGL(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.GLR.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyH(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.HEADERS.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyI(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "IGNORE_BLOCK, IMP_FILE, IMPORT_TERMINALS, INCLUDE_DIRECTORY")
                        : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'B': case 'b':
                return classifyIBs(start, ++p, flag);
            case 'G': case 'g':
                int iIG = Util.prefixMatch(param, ++p, end, "NOREBLOCK", "noreblock");
                return classifyIBs(start, (iIG == 4 ? Util.prefixMatch(param, p + iIG, end, "_BLOCK", "-block") : 0) + p + iIG, flag);
            case 'D': case 'd':
                return classifyID(start, ++p, flag);
            case 'F': case 'f':
                return classifyIF(start, ++p, flag);
            case 'M': case 'm':
                int iIM = Util.prefixMatch(param, ++p, end, "P", "p");
                return classifyIM(start, p + iIM, flag, iIM == 1);
            case 'N': case 'n':
                int iIN = Util.prefixMatch(param, ++p, end, "CLUDE", "clude");
                return classifyIN(start, p + iIN, flag, iIN == 5);
            case 'T': case 't':
                return classifyIT(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyIBs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.IGNORE_BLOCK.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyID(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.INCLUDE_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyIF(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.IMP_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyIM(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "IMP_FILE, IMPORT_TERMINALS")
                        : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'F': case 'f':
                return classifyIMPFs(start, Util.prefixMatch(param, ++p, end, "ILE", "ile") + p, flag);
            case '_': case '-':
                return classifyIMPFs(start, Util.prefixMatch(param, ++p, end, "FILE", "file") + p, flag);
            case 'O': case 'o':
                int iIMPO = Util.prefixMatch(param, ++p, end, "RTTERMINALS", "rtterminals");
                return classifyIMPOs(start, (iIMPO == 2 ? Util.prefixMatch(param, p + iIMPO, end, "_TERMINALS", "-terminals") : 0) + p + iIMPO, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyIMPFs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.IMP_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyIMPOs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.IMPORT_TERMINALS.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyIN(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.INCLUDE_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'D': case 'd':
                int iINCLUDED = Util.prefixMatch(param, ++p, end, "IRECTOR", "irector");
                return classifyINCLUDED(start, p + iINCLUDED, flag, iINCLUDED == 7);
            case '_': case '-':
                int iINCLUDE_ = Util.prefixMatch(param, ++p, end, "DIRECTOR", "director");
                return classifyINCLUDE_(start, p + iINCLUDE_, flag, iINCLUDE_ == 8);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyINCLUDED(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.INCLUDE_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'I': case 'i':
                return classifyINCLUDEDIRECTORI(start, Util.prefixMatch(param, ++p, end, "ES", "es") + p, flag);
            case 'Y': case 'y':
                return classifyINCLUDEDIRECTORY(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyINCLUDEDIRECTORI(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.INCLUDE_DIRECTORIES.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyINCLUDEDIRECTORY(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.INCLUDE_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyINCLUDE_(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.INCLUDE_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'I': case 'i':
                return classifyINCLUDE_DIRECTORI(start, Util.prefixMatch(param, ++p, end, "ES", "es") + p, flag);
            case 'Y': case 'y':
                return classifyINCLUDE_DIRECTORY(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyINCLUDE_DIRECTORI(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.INCLUDE_DIRECTORIES.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyINCLUDE_DIRECTORY(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.INCLUDE_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyIT(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.IMPORT_TERMINALS.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyL(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? option.reportAmbiguousOption(param, start, end, flag, "LALR, LEGACY, LIST")
                         : flag ? OptionEnum.LALR.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                return classifyLA(start, Util.prefixMatch(param, ++p, end, "LR", "lr") + p, flag);
            case 'E': case 'e':
                return classifyLE(start, Util.prefixMatch(param, ++p, end, "GACY", "gacy") + p, flag);
            case 'I': case 'i':
                return classifyLI(start, Util.prefixMatch(param, ++p, end, "ST", "st") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyLA(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.LALR.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.LALR.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyLE(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.LEGACY.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyLI(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.LIST.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyM(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "MARGIN, MAX_CASES")
                        : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                return classifyMA(start, ++p, flag);
            case 'C': case 'c':
                return classifyMC(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyMA(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "MARGIN, MAX_CASES")
                        : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'R': case 'r':
                return classifyMAR(start, Util.prefixMatch(param, ++p, end, "GIN", "gin") + p, flag);
            case 'X': case 'x':
                int iMAX = Util.prefixMatch(param, ++p, end, "CASES", "cases");
                return classifyMAXs(start, (iMAX == 0 ? Util.prefixMatch(param, p + iMAX, end, "_CASES", "-cases") : 0) + p + iMAX, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyMAR(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.MARGIN.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyMAXs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.MAX_CASES.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyMC(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.MAX_CASES.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyN(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.NT_CHECK.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.NAMES.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                return classifyNA(start, Util.prefixMatch(param, ++p, end, "MES", "mes") + p, flag);
            case 'C': case 'c':
                return classifyNCs(start, ++p, flag);
            case 'T': case 't':
                int iNT = Util.prefixMatch(param, ++p, end, "CHECK", "check");
                return classifyNCs(start, (iNT == 0 ? Util.prefixMatch(param, p + iNT, end, "_CHECK", "-check") : 0) + p + iNT, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyNA(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.NAMES.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyNCs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.NT_CHECK.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyO(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "OR_MARKER, OUT_DIRECTORY")
                        : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'D': case 'd':
                return classifyODs(start, ++p, flag);
            case 'U': case 'u':
                int iOU = Util.prefixMatch(param, ++p, end, "TDIRECTORY", "tdirectory");
                return classifyODs(start, (iOU == 1 ? Util.prefixMatch(param, p + iOU, end, "_DIRECTORY", "-directory") : 0) + p + iOU, flag);
            case 'M': case 'm':
                return classifyOMs(start, ++p, flag);
            case 'R': case 'r':
                int iOR = Util.prefixMatch(param, ++p, end, "MARKER", "marker");
                return classifyOMs(start, (iOR == 0 ? Util.prefixMatch(param, p + iOR, end, "_MARKER", "-marker") : 0) + p + iOR, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyODs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.OUT_DIRECTORY.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyOMs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.OR_MARKER.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyP(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "PACKAGE, PARENT_SAVED, PARSETABLE_INTERFACES, PREFIX, PRIORITY, PROGRAMMING_LANGUAGE, PROSTHESES, PRS_FILE")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                return classifyPA(start, ++p, flag);
            case 'F': case 'f':
                return classifyPF(start, ++p, flag);
            case 'I': case 'i':
                return classifyPI(start, ++p, flag);
            case 'L': case 'l':
                return classifyPL(start, ++p, flag);
            case 'R': case 'r':
                return classifyPR(start, ++p, flag);
            case 'S': case 's':
                return classifyPS(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyPA(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "PACKAGE, PARENT_SAVED, PARSETABLE_INTERFACES")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'C': case 'c':
                return classifyPAC(start, Util.prefixMatch(param, ++p, end, "KAGE", "kage") + p, flag);
            case 'R': case 'r':
                return classifyPAR(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyPAC(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.PACKAGE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPAR(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? option.reportAmbiguousOption(param, start, end, flag, "PARENT_SAVED, PARSETABLE_INTERFACES")
                         : flag ? OptionEnum.PARSETABLE_INTERFACES.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'E': case 'e':
                int iPARE = Util.prefixMatch(param, ++p, end, "NTSAVED", "ntsaved");
                return classifyPAREs(start, (iPARE == 2 ? Util.prefixMatch(param, p + iPARE, end, "_SAVED", "-saved") : 0) + p + iPARE, flag);
            case 'S': case 's':
                int iPARS = Util.prefixMatch(param, ++p, end, "ETABLEINTERFACES", "etableinterfaces");
                return classifyPARSs(start, (iPARS == 6 ? Util.prefixMatch(param, p + iPARS, end, "_INTERFACES", "-interfaces") : 0) + p + iPARS, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyPAREs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.PARENT_SAVED.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPARSs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.PARSETABLE_INTERFACES.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.PARSETABLE_INTERFACES.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPF(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.PRS_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPI(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.PARSETABLE_INTERFACES.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.PARSETABLE_INTERFACES.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPL(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.PROGRAMMING_LANGUAGE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPR(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "PREFIX, PRIORITY, PROGRAMMING_LANGUAGE, PROSTHESES, PRS_FILE")
                        : q < 0 ? OptionEnum.PRIORITY.setBooleanValue(false, p, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'E': case 'e':
                return classifyPRE(start, Util.prefixMatch(param, ++p, end, "FIX", "fix") + p, flag);
            case 'I': case 'i':
                return classifyPRI(start, Util.prefixMatch(param, ++p, end, "ORITY", "ority") + p, flag);
            case 'O': case 'o':
                return classifyPRO(start, ++p, flag);
            case 'S': case 's':
                int iPRS = Util.prefixMatch(param, ++p, end, "FILE", "file");
                return classifyPRSs(start, (iPRS == 0 ? Util.prefixMatch(param, p + iPRS, end, "_FILE", "-file") : 0) + p + iPRS, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyPRE(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.PREFIX.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPRI(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.PRIORITY.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPRO(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "PROGRAMMING_LANGUAGE, PROSTHESES")
                        : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'G': case 'g':
                int iPROG = Util.prefixMatch(param, ++p, end, "RAMMINGLANGUAGE", "ramminglanguage");
                return classifyPROGs(start, (iPROG == 7 ? Util.prefixMatch(param, p + iPROG, end, "_LANGUAGE", "-language") : 0) + p + iPROG, flag);
            case 'S': case 's':
                int iPROS = Util.prefixMatch(param, ++p, end, "THES", "thes");
                return classifyPROS(start, p + iPROS, flag, iPROS == 4);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyPROGs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.PROGRAMMING_LANGUAGE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPROS(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.PROSTHESES.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'E': case 'e':
                return classifyPROSTHESE(start, Util.prefixMatch(param, ++p, end, "S", "s") + p, flag);
            case 'I': case 'i':
                return classifyPROSTHESI(start, Util.prefixMatch(param, ++p, end, "S", "s") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyPROSTHESE(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.PROSTHESES.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPROSTHESI(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.PROSTHESIS.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPRSs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.PRS_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyPS(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.PARENT_SAVED.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyQ(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.QUIET.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyR(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "READ_REDUCE, REMAP_TERMINALS")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'E': case 'e':
                return classifyRE(start, ++p, flag);
            case 'R': case 'r':
                return classifyRR(start, ++p, flag);
            case 'T': case 't':
                return classifyRT(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyRE(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "READ_REDUCE, REMAP_TERMINALS")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                int iREA = Util.prefixMatch(param, ++p, end, "DREDUCE", "dreduce");
                return classifyREAs(start, (iREA == 1 ? Util.prefixMatch(param, p + iREA, end, "_REDUCE", "-reduce") : 0) + p + iREA, flag);
            case 'M': case 'm':
                int iREM = Util.prefixMatch(param, ++p, end, "APTERMINALS", "apterminals");
                return classifyREMs(start, (iREM == 2 ? Util.prefixMatch(param, p + iREM, end, "_TERMINALS", "-terminals") : 0) + p + iREM, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyREAs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.READ_REDUCE.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyREMs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.REMAP_TERMINALS.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyRR(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.READ_REDUCE.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyRT(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.REMAP_TERMINALS.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyS(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "SCOPES, SERIALIZE, SHIFT_DEFAULT, SINGLE_PRODUCTIONS, SLR, SOFT_KEYWORDS, STATES, SUFFIX, SYM_FILE")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'C': case 'c':
                return classifySC(start, Util.prefixMatch(param, ++p, end, "OPES", "opes") + p, flag);
            case 'D': case 'd':
                return classifySDs(start, ++p, flag);
            case 'H': case 'h':
                int iSH = Util.prefixMatch(param, ++p, end, "IFTDEFAULT", "iftdefault");
                return classifySDs(start, (iSH == 3 ? Util.prefixMatch(param, p + iSH, end, "_DEFAULT", "-default") : 0) + p + iSH, flag);
            case 'E': case 'e':
                return classifySE(start, Util.prefixMatch(param, ++p, end, "RIALIZE", "rialize") + p, flag);
            case 'F': case 'f':
                return classifySFs(start, ++p, flag);
            case 'Y': case 'y':
                int iSY = Util.prefixMatch(param, ++p, end, "MFILE", "mfile");
                return classifySFs(start, (iSY == 1 ? Util.prefixMatch(param, p + iSY, end, "_FILE", "-file") : 0) + p + iSY, flag);
            case 'I': case 'i':
                int iSI = Util.prefixMatch(param, ++p, end, "NGLEPRODUCTIONS", "ngleproductions");
                return classifySIs(start, (iSI == 4 ? Util.prefixMatch(param, p + iSI, end, "_PRODUCTIONS", "-productions") : 0) + p + iSI, flag);
            case 'P': case 'p':
                return classifySIs(start, ++p, flag);
            case 'K': case 'k':
                return classifySKs(start, ++p, flag);
            case 'O': case 'o':
                int iSO = Util.prefixMatch(param, ++p, end, "FTKEYWORDS", "ftkeywords");
                return classifySKs(start, (iSO == 2 ? Util.prefixMatch(param, p + iSO, end, "_KEYWORDS", "-keywords") : 0) + p + iSO, flag);
            case 'L': case 'l':
                return classifySL(start, Util.prefixMatch(param, ++p, end, "R", "r") + p, flag);
            case 'T': case 't':
                return classifyST(start, Util.prefixMatch(param, ++p, end, "ATES", "ates") + p, flag);
            case 'U': case 'u':
                return classifySU(start, Util.prefixMatch(param, ++p, end, "FFIX", "ffix") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifySC(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.SCOPES.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifySDs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.SHIFT_DEFAULT.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifySE(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.SERIALIZE.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifySFs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.SYM_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifySIs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.SINGLE_PRODUCTIONS.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifySKs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.SOFT_KEYWORDS.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifySL(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.SLR.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyST(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.STATES.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifySU(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.SUFFIX.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyT(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "TAB_FILE, TABLE, TEMPLATE, TRACE, TRAILERS")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                int iTA = Util.prefixMatch(param, ++p, end, "B", "b");
                return classifyTA(start, p + iTA, flag, iTA == 1);
            case 'E': case 'e':
                return classifyTE(start, Util.prefixMatch(param, ++p, end, "MPLATE", "mplate") + p, flag);
            case 'F': case 'f':
                return classifyTF(start, ++p, flag);
            case 'R': case 'r':
                int iTR = Util.prefixMatch(param, ++p, end, "A", "a");
                return classifyTR(start, p + iTR, flag, iTR == 1);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyTA(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "TAB_FILE, TABLE")
                        : q < 0 ? OptionEnum.TABLE.setBooleanValue(false, p, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'F': case 'f':
                return classifyTABFs(start, Util.prefixMatch(param, ++p, end, "ILE", "ile") + p, flag);
            case '_': case '-':
                return classifyTABFs(start, Util.prefixMatch(param, ++p, end, "FILE", "file") + p, flag);
            case 'L': case 'l':
                return classifyTABL(start, Util.prefixMatch(param, ++p, end, "E", "e") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyTABFs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.TAB_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyTABL(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.TABLE.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.TABLE.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyTE(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.TEMPLATE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyTF(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.TAB_FILE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyTR(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? option.reportAmbiguousOption(param, start, end, true, "TRACE, TRAILERS")
                        : q < 0 ? OptionEnum.TRACE.setBooleanValue(false, p, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'C': case 'c':
                return classifyTRAC(start, Util.prefixMatch(param, ++p, end, "E", "e") + p, flag);
            case 'I': case 'i':
                return classifyTRAI(start, Util.prefixMatch(param, ++p, end, "LERS", "lers") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyTRAC(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.TRACE.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.TRACE.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyTRAI(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.TRAILERS.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyV(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return (q < 0 || flag) ? option.reportAmbiguousOption(param, start, end, flag, "VARIABLES, VERBOSE, VISITOR")
                                   : option.classifyBadOption(param, start, end, false);
        }
        switch (c)
        {
            case 'A': case 'a':
                return classifyVA(start, Util.prefixMatch(param, ++p, end, "RIABLES", "riables") + p, flag);
            case 'E': case 'e':
                return classifyVE(start, Util.prefixMatch(param, ++p, end, "RBOSE", "rbose") + p, flag);
            case 'I': case 'i':
                int iVI = Util.prefixMatch(param, ++p, end, "SITOR", "sitor");
                return classifyVI(start, p + iVI, flag, iVI == 5);
            case 'T': case 't':
                return classifyVT(start, ++p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyVA(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.VARIABLES.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.VARIABLES.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyVE(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.VERBOSE.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyVI(int start, int p, boolean flag, boolean classifyChildren)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.VISITOR.setBooleanValue(flag, p, option)
                         : flag ? OptionEnum.VISITOR.setValue(param, start, end, p, q, option)
                                : option.classifyBadOption(param, start, end, false);
        }
        if (!classifyChildren)
        {
            return option.classifyBadOption(param, start, end, flag);
        }
        switch (c)
        {
            case 'T': case 't':
                return classifyVISITORTs(start, Util.prefixMatch(param, ++p, end, "YPE", "ype") + p, flag);
            case '_': case '-':
                return classifyVISITORTs(start, Util.prefixMatch(param, ++p, end, "TYPE", "type") + p, flag);
            default:
                return option.classifyBadOption(param, start, end, flag);
        }
    }

    int classifyVISITORTs(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.VISITOR_TYPE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyVT(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return flag ? q < 0 ? option.reportMissingValue(param, start, end)
                                : OptionEnum.VISITOR_TYPE.setValue(param, start, end, p, q, option)
                        : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyW(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.WARNINGS.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    int classifyX(int start, int p, boolean flag)
    {
        char c;
        if (p == end || (c = param[p]) == '=' || Option.isDelimiter(c))
        {
            int q = Option.valuedOption(param, p, end);
            return q < 0 ? OptionEnum.XREFERENCE.setBooleanValue(flag, p, option)
                         : flag ? option.reportValueNotRequired(param, start, end)
                                : option.classifyBadOption(param, start, end, false);
        }
        return option.classifyBadOption(param, start, end, flag);
    }

    private final Option option;
    private final char[] param;
    private final int end;

}
